/**
 * CK 提取工具
 */

// 全局变量
let templates = [];
let currentResult = '';
let currentTemplateName = ''; // 当前选中的模板名称

// 初始化
document.addEventListener('DOMContentLoaded', function () {
    loadTemplates();
    setupEventListeners();
    loadQinglongConfig();
});

/**
 * 设置事件监听器
 */
function setupEventListeners() {
    // 下拉菜单切换
    document.querySelector('.dropdown-btn').addEventListener('click', function (e) {
        e.stopPropagation();
        const dropdown = document.querySelector('.dropdown-content');
        dropdown.classList.toggle('show');
    });

    // 点击外部关闭下拉菜单
    document.addEventListener('click', function () {
        const dropdown = document.querySelector('.dropdown-content');
        dropdown.classList.remove('show');
    });

    // 批量处理粘贴
    document.getElementById('headers').addEventListener('paste', function (e) {
        const clipboardData = e.clipboardData || window.clipboardData;
        const pastedData = clipboardData.getData('text');

        if (pastedData.includes('---分隔线---')) {
            e.preventDefault();
            setTimeout(() => {
                processBatchRequests(pastedData);
            }, 100);
        }
    });
}

/**
 * 提取 CK
 */
function extractCK() {
    const headers = document.getElementById('headers').value;
    const ck = document.getElementById('ck').value;

    if (!headers.trim()) {
        showToast('请输入请求头信息', 'warning');
        return;
    }

    if (!ck.trim()) {
        showToast('请输入要提取的字段', 'warning');
        return;
    }

    try {
        const result = extractCKFromHeaders(headers, ck);
        displayResult(result);
        showToast('提取成功', 'success');
    } catch (error) {
        showToast(error.message, 'error');
    }
}

/**
 * 解析 cURL 命令
 * @param {string} curlCommand - cURL 命令
 * @returns {Object} 解析后的数据
 */
function parseCurl(curlCommand) {
    const data = {};

    // 移除换行符和多余空格
    let curl = curlCommand.replace(/\\\n/g, ' ').replace(/\s+/g, ' ').trim();

    // 提取 URL
    const urlMatch = curl.match(/curl\s+['"]?([^'">\s]+)['"]?/);
    if (urlMatch) {
        const url = urlMatch[1];
        // 解析 URL 参数
        try {
            const urlObj = new URL(url);
            urlObj.searchParams.forEach((value, key) => {
                data[key.toLowerCase()] = decodeURIComponent(value);
            });
        } catch (e) {
            console.error('URL 解析失败:', e);
        }
    }

    // 提取请求头 (-H 或 --header)
    const headerRegex = /(?:-H|--header)\s+['"]([^'"]+)['"]/g;
    let headerMatch;
    while ((headerMatch = headerRegex.exec(curl)) !== null) {
        const header = headerMatch[1];
        if (header.includes(':')) {
            const [key, ...value] = header.split(':');
            const trimmedKey = key.trim().toLowerCase();
            const trimmedValue = value.join(':').trim();
            if (trimmedValue) {
                data[trimmedKey] = trimmedValue;
                if (trimmedKey === 'user-agent') {
                    data['ua'] = trimmedValue;
                }
            }
        }
    }

    // 提取请求体 (-d 或 --data 或 --data-raw)
    const dataRegex = /(?:-d|--data|--data-raw)\s+['"]([^'"]+)['"]/;
    const dataMatch = curl.match(dataRegex);
    if (dataMatch) {
        const bodyData = dataMatch[1];

        // 尝试解析为 JSON
        try {
            const jsonData = JSON.parse(bodyData);
            Object.keys(jsonData).forEach(key => {
                data[key.toLowerCase()] = jsonData[key];
            });
        } catch (e) {
            // 如果不是 JSON，尝试解析为 URL 编码
            try {
                new URLSearchParams(bodyData).forEach((value, key) => {
                    data[key.toLowerCase()] = decodeURIComponent(value);
                });
            } catch (err) {
                console.error('请求体解析失败:', err);
            }
        }
    }

    return data;
}

/**
 * 从请求头中提取 CK
 * @param {string} input - 请求头信息
 * @param {string} ck - 要提取的字段
 * @returns {string} 提取结果
 */
function extractCKFromHeaders(input, ck) {
    let data = {};

    if (!input.trim()) {
        throw new Error('请求头信息不能为空');
    }

    // 检查是否为 cURL 格式
    if (input.trim().startsWith('curl ')) {
        data = parseCurl(input);
    } else {
        // 原有的解析逻辑
        const lines = input.trim().split('\n');
        const params = new URLSearchParams();

        // 解析 URL 参数 (GET 请求)
        if (lines[0].startsWith('GET') || lines[0].startsWith('http')) {
            const urlPart = lines[0].split(' ')[1] || lines[0];
            const queryString = urlPart.split('?')[1];
            if (queryString) {
                new URLSearchParams(queryString).forEach((v, k) => params.append(k, v));
            }
        }

        // 解析 POST 请求体参数
        if (lines[0].startsWith('POST')) {
            const emptyLineIndex = lines.findIndex(l => l.trim() === '');
            if (emptyLineIndex !== -1) {
                const bodyLines = lines.slice(emptyLineIndex + 1);
                const bodyText = bodyLines.join('');

                // 检查 Content-Type 是否为 JSON
                const contentType = lines.find(line => line.toLowerCase().includes('content-type'));
                if (contentType && contentType.toLowerCase().includes('application/json')) {
                    try {
                        const jsonData = JSON.parse(bodyText);
                        Object.keys(jsonData).forEach(key => {
                            data[key.toLowerCase()] = jsonData[key];
                        });
                    } catch (e) {
                        console.error('JSON 解析失败:', e);
                    }
                } else {
                    // 处理 URL 编码的表单数据
                    new URLSearchParams(bodyText).forEach((v, k) => params.append(k, v));
                }
            }
        }

        // 合并所有参数并解码
        params.forEach((value, key) => {
            data[key.toLowerCase()] = decodeURIComponent(value);
        });

        // 处理请求头
        lines.forEach(line => {
            if (line.includes(':')) {
                const [key, ...value] = line.split(':');
                const trimmedKey = key.trim().toLowerCase();
                const trimmedValue = value.join(':').trim();
                if (trimmedValue) {
                    data[trimmedKey] = trimmedValue;
                    if (trimmedKey === 'user-agent') {
                        data['ua'] = trimmedValue;
                    }
                }
            } else if (line.includes('=')) {
                const [key, value] = line.split('=');
                const trimmedKey = key.trim().toLowerCase();
                const trimmedValue = value.split('&')[0].trim();
                if (trimmedValue) {
                    data[trimmedKey] = trimmedValue;
                }
            }
        });
    }

    // 提取指定字段
    const ckArray = ck.split('#');
    if (ckArray.length === 0) {
        throw new Error('请输入要提取的字段');
    }

    return ckArray.map(key => {
        const lowerKey = key.toLowerCase();
        let value = '';

        if (lowerKey === 'ua' || lowerKey === 'user-agent') {
            value = data['user-agent'] || data['ua'] || '';
        } else if (lowerKey === 'cookie') {
            value = data['cookie'] || '';
        } else {
            value = data[lowerKey] || '';
        }

        // 如果值为空，显示"缺"加上字段名
        return value || `缺${key}`;
    }).join('#');
}

/**
 * 批量处理请求
 * @param {string} pastedData - 粘贴的数据
 */
function processBatchRequests(pastedData) {
    const requests = pastedData.split('---分隔线---');
    const ck = document.getElementById('ck').value;

    const results = requests.map(request => {
        try {
            return extractCKFromHeaders(request.trim(), ck);
        } catch (error) {
            return null;
        }
    }).filter(result => result);

    if (results.length > 0) {
        displayResult(results.join('\n'));
        showToast(`成功处理 ${results.length} 条数据`, 'success');
    } else {
        showToast('批量处理失败', 'error');
    }
}

/**
 * 显示结果
 * @param {string} result - 提取结果
 */
function displayResult(result) {
    currentResult = result;
    document.getElementById('result').textContent = result;
    document.getElementById('copyButton').style.display = 'inline-block';
    document.getElementById('sendToQinglongButton').style.display = 'inline-block';
}

/**
 * 复制结果
 */
async function copyResult() {
    if (!currentResult) {
        showToast('没有内容可复制', 'warning');
        return;
    }

    try {
        await navigator.clipboard.writeText(currentResult);
        showToast('已复制到剪贴板', 'success');
    } catch (error) {
        // 降级方案
        const textArea = document.createElement('textarea');
        textArea.value = currentResult;
        document.body.appendChild(textArea);
        textArea.select();
        try {
            document.execCommand('copy');
            showToast('已复制到剪贴板', 'success');
        } catch (err) {
            showToast('复制失败', 'error');
        }
        document.body.removeChild(textArea);
    }
}

/**
 * 清空所有
 */
function clearAll() {
    document.getElementById('headers').value = '';
    document.getElementById('result').textContent = '';
    document.getElementById('copyButton').style.display = 'none';
    document.getElementById('sendToQinglongButton').style.display = 'none';
    currentResult = '';
    currentTemplateName = ''; // 清空模板名称
    showToast('已清空', 'info');
}

/**
 * 添加模板
 */
function addTemplate() {
    const name = prompt('请输入模板名称:');
    if (!name) return;

    const fields = prompt('请输入要提取的字段 (用 # 分隔):');
    if (!fields) return;

    const variableName = prompt('请输入变量名:');
    if (!variableName) return;

    const template = {
        name: name,
        fields: fields,
        variableName: variableName
    };

    templates.push(template);
    saveTemplates();
    renderTemplates();
    showToast('模板添加成功', 'success');
}

/**
 * 加载模板
 */
function loadTemplates() {
    const saved = localStorage.getItem('ck-templates');
    if (saved) {
        try {
            templates = JSON.parse(saved);
        } catch (error) {
            templates = [];
        }
    }
    renderTemplates();
}

/**
 * 保存模板
 */
function saveTemplates() {
    localStorage.setItem('ck-templates', JSON.stringify(templates));
}

/**
 * 渲染模板列表
 */
function renderTemplates() {
    const container = document.getElementById('fieldTemplates');
    container.innerHTML = '';

    templates.forEach((template, index) => {
        const item = document.createElement('div');
        item.className = 'dropdown-item';
        item.textContent = template.name;
        item.onclick = function () {
            applyTemplate(template);
        };
        container.appendChild(item);
    });

    if (templates.length === 0) {
        const empty = document.createElement('div');
        empty.className = 'dropdown-item';
        empty.textContent = '暂无模板';
        empty.style.color = 'var(--text-secondary)';
        empty.style.cursor = 'default';
        container.appendChild(empty);
    }
}

/**
 * 应用模板
 * @param {Object} template - 模板对象
 */
function applyTemplate(template) {
    document.getElementById('ck').value = template.fields;
    document.getElementById('variableName').value = template.variableName || '';
    currentTemplateName = template.name; // 保存当前模板名称
    document.querySelector('.dropdown-content').classList.remove('show');
    showToast(`已应用模板: ${template.name}`, 'info');
}

/**
 * 显示青龙对话框
 */
function showQinglongDialog() {
    if (!currentResult) {
        showToast('没有结果可传送', 'warning');
        return;
    }

    // 自动填充备注名到青龙对话框
    const remarkName = document.getElementById('remarkName').value;
    if (remarkName) {
        document.getElementById('qinglongUserName').value = remarkName;
    }

    document.getElementById('qinglongModal').style.display = 'flex';
}

/**
 * 关闭青龙对话框
 */
function closeQinglongDialog() {
    document.getElementById('qinglongModal').style.display = 'none';
}

/**
 * 发送到青龙
 */
async function sendToQinglong() {
    const host = document.getElementById('qinglongHost').value;
    const client = document.getElementById('qinglongClient').value;
    const secret = document.getElementById('qinglongSecret').value;
    const userName = document.getElementById('qinglongUserName').value;
    const variableName = document.getElementById('variableName').value;

    if (!host || !client || !secret) {
        showToast('请填写完整的青龙配置', 'warning');
        return;
    }

    if (!currentResult) {
        showToast('没有结果可传送', 'warning');
        return;
    }

    // 保存配置
    saveQinglongConfig({ host, client, secret, userName });

    try {
        showToast('正在连接青龙面板...', 'info');

        // 1. 获取 token
        const token = await getQinglongToken(host, client, secret);

        if (!token) {
            showToast('获取青龙 Token 失败', 'error');
            return;
        }

        // 2. 获取备注名称
        let remarkName;
        if (currentTemplateName && userName) {
            // 场景1：使用模板 + 填写用户名
            remarkName = `${currentTemplateName}${userName}`;
        } else if (userName) {
            // 场景2：不使用模板，只填写用户名
            remarkName = userName;
        } else {
            // 场景3：都不填写
            remarkName = '不知脚本名';
        }

        // 3. 查找或创建环境变量
        const success = await updateOrCreateEnv(host, token, variableName, currentResult, remarkName);

        if (success) {
            showToast('传送成功！', 'success');
            closeQinglongDialog();
        } else {
            showToast('传送失败', 'error');
        }
    } catch (error) {
        showToast('传送失败: ' + error.message, 'error');
        console.error('青龙传送错误:', error);
    }
}

/**
 * 获取青龙 Token
 * @param {string} host - 青龙地址
 * @param {string} client - Client ID
 * @param {string} secret - Client Secret
 * @returns {Promise<string>} Token
 */
async function getQinglongToken(host, client, secret) {
    try {
        const url = `${host}/open/auth/token?client_id=${client}&client_secret=${secret}`;
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Content-Type': 'application/json'
            }
        });

        const data = await response.json();

        if (data.code === 200 && data.data && data.data.token) {
            return `${data.data.token_type} ${data.data.token}`;
        } else {
            console.error('获取 Token 失败:', data);
            return null;
        }
    } catch (error) {
        console.error('获取 Token 错误:', error);
        return null;
    }
}

/**
 * 更新或创建环境变量
 * @param {string} host - 青龙地址
 * @param {string} token - 授权 Token
 * @param {string} variableName - 变量名
 * @param {string} value - 变量值
 * @param {string} remarkName - 备注名称
 * @returns {Promise<boolean>} 是否成功
 */
async function updateOrCreateEnv(host, token, variableName, value, remarkName) {
    try {
        // 1. 获取所有环境变量
        const envs = await getQinglongEnvs(host, token);

        if (!envs) {
            return false;
        }

        // 2. 通过备注名称查找，如果没找到则通过变量名查找
        let existingEnv = null;

        // 优先通过备注名称查找
        for (const env of envs) {
            if (env.remarks === remarkName) {
                existingEnv = env;
                break;
            }
        }

        // 如果通过备注没找到，再通过变量名和备注的组合查找
        if (!existingEnv && variableName) {
            for (const env of envs) {
                if (env.name === variableName && env.remarks === remarkName) {
                    existingEnv = env;
                    break;
                }
            }
        }

        // 3. 更新或创建（参考 qionglong.php 的逻辑）
        if (existingEnv && existingEnv.id) {
            // 找到了现有环境变量 → 更新
            console.log('找到现有环境变量，执行更新操作');
            return await updateQinglongEnv(host, token, existingEnv.id, variableName, value, remarkName);
        } else {
            // 没找到 → 创建新的
            console.log('未找到现有环境变量，执行创建操作');
            return await createQinglongEnv(host, token, variableName, value, remarkName);
        }
    } catch (error) {
        console.error('更新或创建环境变量错误:', error);
        return false;
    }
}

/**
 * 获取青龙环境变量列表
 * @param {string} host - 青龙地址
 * @param {string} token - 授权 Token
 * @returns {Promise<Array>} 环境变量列表
 */
async function getQinglongEnvs(host, token) {
    try {
        const url = `${host}/open/envs`;
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Authorization': token,
                'Content-Type': 'application/json'
            }
        });

        const data = await response.json();

        if (data.code === 200 && data.data) {
            return data.data;
        } else {
            console.error('获取环境变量失败:', data);
            return null;
        }
    } catch (error) {
        console.error('获取环境变量错误:', error);
        return null;
    }
}

/**
 * 更新青龙环境变量
 * @param {string} host - 青龙地址
 * @param {string} token - 授权 Token
 * @param {string} id - 环境变量 ID
 * @param {string} name - 变量名
 * @param {string} value - 变量值
 * @param {string} remarks - 备注
 * @returns {Promise<boolean>} 是否成功
 */
async function updateQinglongEnv(host, token, id, name, value, remarks) {
    try {
        const url = `${host}/open/envs`;
        const response = await fetch(url, {
            method: 'PUT',
            headers: {
                'Authorization': token,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                id: id,
                name: name,
                value: value,
                remarks: remarks
            })
        });

        const data = await response.json();

        if (data.code === 200) {
            console.log('环境变量更新成功');
            return true;
        } else {
            console.error('环境变量更新失败:', data);
            // 显示详细错误信息
            const errorMsg = data.message || data.error || '未知错误';
            showToast(`更新失败: ${errorMsg}`, 'error', 5000);
            return false;
        }
    } catch (error) {
        console.error('更新环境变量错误:', error);
        return false;
    }
}

/**
 * 创建青龙环境变量
 * @param {string} host - 青龙地址
 * @param {string} token - 授权 Token
 * @param {string} name - 变量名
 * @param {string} value - 变量值
 * @param {string} remarks - 备注
 * @returns {Promise<boolean>} 是否成功
 */
async function createQinglongEnv(host, token, name, value, remarks) {
    try {
        const url = `${host}/open/envs`;
        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'Authorization': token,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify([
                {
                    name: name,
                    value: value,
                    remarks: remarks
                }
            ])
        });

        const data = await response.json();

        if (data.code === 200) {
            console.log('环境变量创建成功');
            return true;
        } else {
            console.error('环境变量创建失败:', data);
            // 显示详细错误信息
            const errorMsg = data.message || data.error || '未知错误';
            showToast(`创建失败: ${errorMsg}`, 'error', 5000);
            return false;
        }
    } catch (error) {
        console.error('创建环境变量错误:', error);
        return false;
    }
}

/**
 * 保存青龙配置
 * @param {Object} config - 配置对象
 */
function saveQinglongConfig(config) {
    localStorage.setItem('qinglong-config', JSON.stringify(config));
}

/**
 * 加载青龙配置
 */
function loadQinglongConfig() {
    const saved = localStorage.getItem('qinglong-config');
    if (saved) {
        try {
            const config = JSON.parse(saved);
            document.getElementById('qinglongHost').value = config.host || '';
            document.getElementById('qinglongClient').value = config.client || '';
            document.getElementById('qinglongSecret').value = config.secret || '';
            document.getElementById('qinglongUserName').value = config.userName || '';
        } catch (error) {
            console.error('加载青龙配置失败:', error);
        }
    }
}

/**
 * 显示提示消息
 * @param {string} message - 提示消息
 * @param {string} type - 消息类型
 * @param {number} duration - 显示时长（毫秒）
 */
function showToast(message, type = 'info', duration = 3000) {
    const toast = document.createElement('div');
    toast.className = `toast toast-${type}`;
    toast.textContent = message;
    document.body.appendChild(toast);

    setTimeout(() => {
        toast.classList.add('show');
    }, 10);

    setTimeout(() => {
        toast.classList.remove('show');
        setTimeout(() => {
            document.body.removeChild(toast);
        }, 300);
    }, duration);
}
